#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cstring>
using namespace std;

const int INF = (int)1e9;
const int T_CONST = 10100;
const int N = 110;

int dp[N][T_CONST];

vector <int> compGt[N];
int tailColor[N];
vector <int> g[N], gt[N];
int cost[N], t[N], cnt[N];
int position[N];
bool used[N];
int color[N];
int sizeComp[N];
int headColor[N];
int listTime[T_CONST];
int cc = 1;
vector <int> topSort, order;
int n, m, T;

struct MaxQueue
{
	int tail[T_CONST], head[T_CONST];
	int maxTail[T_CONST], maxHead[T_CONST];
	int tailPtr, headPtr;
	MaxQueue ()
	{
		tailPtr = headPtr = 0;
	}
	int getMax()
	{
		return max((tailPtr == 0 ? -INF : maxTail[tailPtr - 1]), (headPtr == 0 ? -INF : maxHead[headPtr - 1]));
	}
	void push(int val)
	{
		head[headPtr] = val;
		maxHead[headPtr] = max((headPtr == 0 ? -INF : maxHead[headPtr - 1]), val);
		headPtr++;
	}
	void pop()
	{
		if (tailPtr > 0)
			tailPtr--;
		else
		{
			for (int i = headPtr - 1; i >= 0; i--)
			{
				tail[tailPtr] = head[i];
				maxTail[tailPtr] = max((tailPtr == 0 ? -INF : maxTail[tailPtr - 1]), tail[tailPtr]);
				tailPtr++;
			}
			headPtr = 0;
			pop();
		}
	}
	int size()
	{
		return tailPtr + headPtr;
	}
} maxQ;

bool read()
{
	scanf("%d%d%d", &n, &m, &T);

	if (n == 0)
		return false;

	for (int i = 0; i < N; i++)
		compGt[i].clear();
	for (int i = 0; i < n; i++)
	{
		g[i].clear();
		gt[i].clear();
	}

	for (int i = 0; i < n; i++)
		for (int s = 0; s <= T; s++)
			dp[i][s] = 0;

	cc = 1;
	
	memset(used, 0, sizeof(used));
	memset(color, 0, sizeof(color));
	memset(sizeComp, 0, sizeof(sizeComp));
	memset(headColor, 0, sizeof(headColor));
	memset(listTime, 0, sizeof(listTime));
	memset(position, 0, sizeof(position));
	memset(tailColor, 0, sizeof(tailColor));

	topSort.clear();
	order.clear();

	for (int i = 0; i < n; i++)
		scanf("%d%d%d", &cost[i], &t[i], &cnt[i]);

	for (int i = 0; i < m; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		a--, b--;
		g[a].push_back(b);
		gt[b].push_back(a);
	}

	return true;
}

void dfs(int v)
{
	used[v] = 1;
	for (int i = 0; i < (int)g[v].size(); i++)
	{
		int to = g[v][i];
		if (!used[to])
			dfs(to);
	}
	topSort.push_back(v);
}

void paint(int v)
{
	sizeComp[cc]++;
	color[v] = cc;
	for (int i = 0; i < (int)gt[v].size(); i++)
	{
		int to = gt[v][i];
		if (color[to] == 0)
			paint(to);
		else
		{
			compGt[cc].push_back(color[to]);
		}
	}

	position[v] = order.size();
	order.push_back(v);
}

void calcDp()
{
/*	for (int i = 0; i < n; i++)
		cout << order[i] + 1 << ' ';
	cout << endl;
	for (int i = 0; i < n; i++)
		cout << cnt[order[i]] << ' ';
	cout << endl;
	for (int i = 0; i < n; i++)
		cout << position[i] << ' ' ;
	cout << endl;
*/	for (int i = 0; i < n; i++)
	{
		int v = order[i];
		if (tailColor[color[v]] == v)
		{
			for (int q = 0; q < compGt[color[v]].size(); q++)
			{
				int colorTo = compGt[color[v]][q];
				for (int tme = 0; tme <= T; tme++)
					dp[v][tme] = max(dp[v][tme], dp[headColor[colorTo]][tme]);
			}
		}
		else
		{
			int prevV = order[i - 1];
			for (int tme = 0; tme <= T; tme++)
				dp[v][tme] = max(dp[v][tme], dp[prevV][tme]);
		}
		for (int s = 0; s < t[v]; s++)
		{
			int indT = 0;
			for (int q = s; q <= T; q += t[v])
				listTime[indT++] = q;
			for (int q = indT - 1; q >= 0; q--)
			{
				int curTime = listTime[q];
				maxQ.push(dp[v][curTime] - q * cost[v]);
				int mayDel = q + cnt[v];
				if (mayDel < indT)
				{
					dp[v][listTime[mayDel]] = maxQ.getMax() + mayDel * cost[v];
					maxQ.pop();
				}
			}
			while (maxQ.size() > 0)
			{
				int endTime = s + (maxQ.size() - 1) * t[v];
				dp[v][endTime] = maxQ.getMax() + (maxQ.size() - 1) * cost[v];
				maxQ.pop();
			}
		}
	}
}

void solve()
{
	for (int i = 0; i < n; i++)
	{
		if (!used[i])
			dfs(i);
	}
	reverse(topSort.begin(), topSort.end());
	for (int i = 0; i < n; i++)
	{
		if (color[topSort[i]] == 0)
		{
			paint(topSort[i]);
			cc++;
		}
	}
	for (int i = 0; i < n; i++)
	{
		bool loop = false;
		for (int s = 0; s < (int)g[i].size(); s++)
		{
			if (g[i][s] == i)
				loop = true;
		}
		if (sizeComp[color[i]] == 1 && !loop)
			cnt[i] = 1;
	}
	for (int i = 0; i < n; i++)
	{
		int v = order[i];
		headColor[color[v]] = v;
	}
	for (int i = n - 1; i >= 0; i--)
	{
		int v = order[i];
		tailColor[color[v]] = v;
	}
	calcDp();
	int answer = 0;
	for (int i = 0; i < n; i++)
		for (int s = 0; s <= T; s++)
			answer = max(answer, dp[i][s]);
	printf("%d\n", answer);
}

int main()
{
	freopen ("input.txt", "r", stdin);
	freopen ("output.txt", "w", stdout);
	while (read())
	{
		solve();
	}
	return 0;
}